ஜாவாஸ்கிரிப்ட் கன்கரென்ட் பி-ட்ரீ: த்ரெட்-பாதுகாப்பான ட்ரீ அமைப்புகளில் ஒரு ஆழமான பார்வை

நவீன பயன்பாட்டு மேம்பாட்டுத் துறையில், குறிப்பாக Node.js மற்றும் Deno போன்ற சர்வர்-சைட் ஜாவாஸ்கிரிப்ட் சூழல்களின் வளர்ச்சியுடன், திறமையான மற்றும் நம்பகமான தரவு கட்டமைப்புகளின் தேவை மிக முக்கியமாகிறது. கன்கரென்ட் செயல்பாடுகளைக் கையாளும்போது, தரவு ஒருமைப்பாடு மற்றும் செயல்திறனை ஒரே நேரத்தில் உறுதி செய்வது ஒரு குறிப்பிடத்தக்க சவாலாக உள்ளது. இங்குதான் கன்கரென்ட் பி-ட்ரீ முக்கியத்துவம் பெறுகிறது. இந்தக் கட்டுரை ஜாவாஸ்கிரிப்டில் செயல்படுத்தப்பட்ட கன்கரென்ட் பி-ட்ரீகளைப் பற்றிய ஒரு விரிவான ஆய்வை வழங்குகிறது, அவற்றின் கட்டமைப்பு, நன்மைகள், செயல்படுத்தல் பரிசீலனைகள் மற்றும் நடைமுறைப் பயன்பாடுகளில் கவனம் செலுத்துகிறது.

பி-ட்ரீகளைப் புரிந்துகொள்ளுதல்

கன்கரென்சியின் நுணுக்கங்களுக்குள் செல்வதற்கு முன், பி-ட்ரீகளின் அடிப்படைக் கொள்கைகளைப் புரிந்துகொண்டு ஒரு உறுதியான அடித்தளத்தை உருவாக்குவோம். ஒரு பி-ட்ரீ என்பது டிஸ்க் I/O செயல்பாடுகளை மேம்படுத்துவதற்காக வடிவமைக்கப்பட்ட ஒரு சுய-சமநிலைப்படுத்தும் ட்ரீ தரவு கட்டமைப்பாகும், இது தரவுத்தள அட்டவணைப்படுத்தல் மற்றும் கோப்பு முறைமைகளுக்கு குறிப்பாக ஏற்றது. பைனரி தேடல் ட்ரீகளைப் போலன்றி, பி-ட்ரீகள் பல குழந்தைகளைக் கொண்டிருக்கலாம், இது ட்ரீயின் உயரத்தை கணிசமாகக் குறைத்து, ஒரு குறிப்பிட்ட கீயைக் கண்டறியத் தேவையான டிஸ்க் அணுகல்களின் எண்ணிக்கையைக் குறைக்கிறது. ஒரு வழக்கமான பி-ட்ரீயில்:

• ஒவ்வொரு நோடும் கீகளின் தொகுப்பு மற்றும் சைல்டு நோடுகளுக்கான பாயிண்டர்களைக் கொண்டுள்ளது.
• அனைத்து லீஃப் நோடுகளும் ஒரே மட்டத்தில் உள்ளன, இது சமநிலையான அணுகல் நேரங்களை உறுதி செய்கிறது.
• ஒவ்வொரு நோடும் (ரூட்டைத் தவிர) t-1 மற்றும் 2t-1 கீகளுக்கு இடையில் கொண்டிருக்கும், இங்கு t என்பது பி-ட்ரீயின் குறைந்தபட்ச டிகிரி ஆகும்.
• ரூட் நோடு 1 மற்றும் 2t-1 கீகளுக்கு இடையில் கொண்டிருக்கலாம்.
• ஒரு நோடிற்குள் உள்ள கீகள் வரிசைப்படுத்தப்பட்ட வரிசையில் சேமிக்கப்படுகின்றன.

பி-ட்ரீகளின் சமநிலையான தன்மை தேடல், செருகுதல் மற்றும் நீக்குதல் செயல்பாடுகளுக்கு மடக்கை நேர சிக்கலை (logarithmic time complexity) உறுதி செய்கிறது, இது பெரிய தரவுத்தொகுப்புகளைக் கையாள்வதற்கான சிறந்த தேர்வாக அமைகிறது. உதாரணமாக, ஒரு உலகளாவிய இ-காமர்ஸ் தளத்தில் சரக்குகளை நிர்வகிப்பதைக் கருத்தில் கொள்ளுங்கள். ஒரு பி-ட்ரீ அட்டவணை, சரக்கு மில்லியன் கணக்கான பொருட்களாக வளர்ந்தாலும், ஒரு தயாரிப்பு ஐடியின் அடிப்படையில் தயாரிப்பு விவரங்களை விரைவாக மீட்டெடுக்க அனுமதிக்கிறது.

கன்கரென்சியின் தேவை

சிங்கிள்-த்ரெட்டட் சூழல்களில், பி-ட்ரீ செயல்பாடுகள் ஒப்பீட்டளவில் நேரடியானவை. இருப்பினும், நவீன பயன்பாடுகளுக்கு பெரும்பாலும் பல கோரிக்கைகளை ஒரே நேரத்தில் கையாள வேண்டியுள்ளது. உதாரணமாக, ஒரே நேரத்தில் பல கிளையன்ட் கோரிக்கைகளைக் கையாளும் ஒரு வலை சேவையகத்திற்கு, தரவு ஒருமைப்பாட்டை சமரசம் செய்யாமல் கன்கரென்ட் ரீட் மற்றும் ரைட் செயல்பாடுகளைத் தாங்கக்கூடிய ஒரு தரவு கட்டமைப்பு தேவை. இந்தச் சூழ்நிலைகளில், சரியான ஒத்திசைவு வழிமுறைகள் இல்லாமல் ஒரு நிலையான பி-ட்ரீயைப் பயன்படுத்துவது ரேஸ் கண்டிஷன்கள் மற்றும் தரவு சிதைவுக்கு வழிவகுக்கும். ஒரே நிகழ்வுக்கான டிக்கெட்டுகளை ஒரே நேரத்தில் முன்பதிவு செய்ய முயற்சிக்கும் பல பயனர்களைக் கொண்ட ஆன்லைன் டிக்கெட் முன்பதிவு முறையின் காட்சியைக் கவனியுங்கள். கன்கரென்சி கட்டுப்பாடு இல்லாமல், டிக்கெட்டுகள் அதிகமாக விற்கப்படலாம், இது ஒரு மோசமான பயனர் அனுபவத்திற்கும் சாத்தியமான நிதி இழப்புகளுக்கும் வழிவகுக்கும்.

கன்கரென்சி கட்டுப்பாடு, பல த்ரெட்கள் அல்லது செயல்முறைகள் பகிரப்பட்ட தரவை பாதுகாப்பாகவும் திறமையாகவும் அணுகுவதையும் மாற்றுவதையும் உறுதி செய்வதை நோக்கமாகக் கொண்டுள்ளது. ஒரு கன்கரென்ட் பி-ட்ரீயை செயல்படுத்துவது, ட்ரீயின் நோடுகளுக்கு ஒரே நேரத்தில் அணுகலைக் கையாளும் வழிமுறைகளைச் சேர்ப்பதை உள்ளடக்கியது, தரவு முரண்பாடுகளைத் தடுத்து ஒட்டுமொத்த கணினி செயல்திறனைப் பராமரிக்கிறது.

கன்கரென்சி கட்டுப்பாட்டு நுட்பங்கள்

பி-ட்ரீகளில் கன்கரென்சி கட்டுப்பாட்டை அடைய பல நுட்பங்களைப் பயன்படுத்தலாம். இங்கே மிகவும் பொதுவான அணுகுமுறைகளில் சில:

1. லாக்கிங் (Locking)

லாக்கிங் என்பது பகிரப்பட்ட வளங்களுக்கான அணுகலைக் கட்டுப்படுத்தும் ஒரு அடிப்படைக் கன்கரென்சி கட்டுப்பாட்டு முறையாகும். ஒரு பி-ட்ரீயின் சூழலில், லாக்குகளை முழு ட்ரீ (coarse-grained locking) அல்லது தனிப்பட்ட நோடுகள் (fine-grained locking) போன்ற பல்வேறு மட்டங்களில் பயன்படுத்தலாம். ஒரு த்ரெட் ஒரு நோடை மாற்ற வேண்டியிருக்கும் போது, அது அந்த நோடில் ஒரு லாக்கைப் பெறுகிறது, மற்ற த்ரெட்கள் லாக் வெளியிடப்படும் வரை அதை அணுகுவதைத் தடுக்கிறது.

கோர்ஸ்-கிரைன்டு லாக்கிங் (Coarse-Grained Locking)

கோர்ஸ்-கிரைன்டு லாக்கிங் என்பது முழு பி-ட்ரீக்கும் ஒரு ஒற்றை லாக்கைப் பயன்படுத்துவதை உள்ளடக்கியது. செயல்படுத்த எளிமையானதாக இருந்தாலும், இந்த அணுகுமுறை கன்கரென்சியை கணிசமாகக் கட்டுப்படுத்தலாம், ஏனெனில் எந்த நேரத்திலும் ஒரே ஒரு த்ரெட் மட்டுமே ட்ரீயை அணுக முடியும். இந்த அணுகுமுறை ஒரு பெரிய சூப்பர் மார்க்கெட்டில் ஒரே ஒரு செக்-அவுட் கவுண்டர் திறந்திருப்பதற்கு ஒப்பானது - இது எளிமையானது ஆனால் நீண்ட வரிசைகளையும் தாமதங்களையும் ஏற்படுத்துகிறது.

ஃபைன்-கிரைன்டு லாக்கிங் (Fine-Grained Locking)

ஃபைன்-கிரைன்டு லாக்கிங், மறுபுறம், பி-ட்ரீயில் உள்ள ஒவ்வொரு நோடிற்கும் தனித்தனி லாக்குகளைப் பயன்படுத்துவதை உள்ளடக்கியது. இது பல த்ரெட்கள் ஒரே நேரத்தில் ட்ரீயின் வெவ்வேறு பகுதிகளை அணுக அனுமதிக்கிறது, ஒட்டுமொத்த செயல்திறனை மேம்படுத்துகிறது. இருப்பினும், ஃபைன்-கிரைன்டு லாக்கிங் லாக்குகளை நிர்வகிப்பதிலும் டெட்லாக்குகளைத் தடுப்பதிலும் கூடுதல் சிக்கலை அறிமுகப்படுத்துகிறது. ஒரு பெரிய சூப்பர் மார்க்கெட்டின் ஒவ்வொரு பகுதிக்கும் அதன் சொந்த செக்-அவுட் கவுண்டர் இருப்பதாக கற்பனை செய்து பாருங்கள் - இது மிகவும் வேகமான செயலாக்கத்தை அனுமதிக்கிறது ஆனால் அதிக மேலாண்மை மற்றும் ஒருங்கிணைப்பு தேவைப்படுகிறது.

2. ரீட்-ரைட் லாக்குகள் (Read-Write Locks)

ரீட்-ரைட் லாக்குகள் (பகிரப்பட்ட-பிரத்தியேக லாக்குகள் என்றும் அழைக்கப்படுகின்றன) ரீட் மற்றும் ரைட் செயல்பாடுகளை வேறுபடுத்துகின்றன. பல த்ரெட்கள் ஒரே நேரத்தில் ஒரு நோடில் ரீட் லாக்கைப் பெறலாம், ஆனால் ஒரே ஒரு த்ரெட் மட்டுமே ரைட் லாக்கைப் பெற முடியும். இந்த அணுகுமுறை, ரீட் செயல்பாடுகள் ட்ரீயின் கட்டமைப்பை மாற்றாது என்ற உண்மையை சாதகமாகப் பயன்படுத்துகிறது, இது ரைட் செயல்பாடுகளை விட ரீட் செயல்பாடுகள் அடிக்கடி நிகழும்போது அதிக கன்கரென்சியை அனுமதிக்கிறது. உதாரணமாக, ஒரு தயாரிப்பு κατάλογு அமைப்பில், ரைட்களை (தயாரிப்பு விவரங்களைப் புதுப்பித்தல்) விட ரீட்கள் (தயாரிப்புத் தகவலை உலாவல்) மிகவும் அடிக்கடி நிகழ்கின்றன. ரீட்-ரைட் லாக்குகள் ஒரு தயாரிப்பின் தகவல் புதுப்பிக்கப்படும்போது பிரத்தியேக அணுகலை உறுதி செய்யும் அதே வேளையில், பல பயனர்களை ஒரே நேரத்தில் κατάλογுவை உலாவ அனுமதிக்கும்.

3. ஆப்டிமிஸ்டிக் லாக்கிங் (Optimistic Locking)

ஆப்டிமிஸ்டிக் லாக்கிங் முரண்பாடுகள் அரிதானவை என்று கருதுகிறது. ஒரு நோடை அணுகுவதற்கு முன் லாக்குகளைப் பெறுவதற்குப் பதிலாக, ஒவ்வொரு த்ரெட்டும் நோடைப் படித்து அதன் செயல்பாட்டைச் செய்கிறது. மாற்றங்களைச் செய்வதற்கு முன், அந்த நேரத்தில் நோடு மற்றொரு த்ரெட்டால் மாற்றப்பட்டுள்ளதா என்பதை த்ரெட் சரிபார்க்கிறது. இந்தச் சரிபார்ப்பை நோடுடன் தொடர்புடைய பதிப்பு எண் அல்லது நேர முத்திரையை ஒப்பிடுவதன் மூலம் செய்ய முடியும். ஒரு முரண்பாடு கண்டறியப்பட்டால், த்ரெட் செயல்பாட்டை மீண்டும் முயற்சிக்கிறது. ஆப்டிமிஸ்டிக் லாக்கிங், ரைட் செயல்பாடுகளை விட ரீட் செயல்பாடுகள் கணிசமாக அதிகமாக இருக்கும் மற்றும் முரண்பாடுகள் அரிதாக இருக்கும் சூழ்நிலைகளுக்கு ஏற்றது. ஒரு கூட்டு ஆவண எடிட்டிங் அமைப்பில், ஆப்டிமிஸ்டிக் லாக்கிங் பல பயனர்களை ஒரே நேரத்தில் ஆவணத்தைத் திருத்த அனுமதிக்கலாம். இரண்டு பயனர்கள் ஒரே பகுதியை ஒரே நேரத்தில் திருத்த நேர்ந்தால், கணினி அவர்களில் ஒருவரை முரண்பாட்டை கைமுறையாக தீர்க்கும்படி கேட்கலாம்.

4. லாக்-ஃப்ரீ நுட்பங்கள் (Lock-Free Techniques)

லாக்-ஃப்ரீ நுட்பங்கள், கம்ப்பேர்-அண்ட்-ஸ்வாப் (CAS) செயல்பாடுகள் போன்றவை, லாக்குகளின் பயன்பாட்டை முற்றிலுமாகத் தவிர்க்கின்றன. இந்த நுட்பங்கள், செயல்பாடுகள் த்ரெட்-பாதுகாப்பான முறையில் செய்யப்படுவதை உறுதிசெய்ய, அடிப்படைக் வன்பொருளால் வழங்கப்படும் அணு செயல்பாடுகளை நம்பியுள்ளன. லாக்-ஃப்ரீ அல்காரிதம்கள் சிறந்த செயல்திறனை வழங்க முடியும், ஆனால் அவற்றைச் சரியாகச் செயல்படுத்துவது மிகவும் கடினம். ஒரு சிக்கலான கட்டமைப்பை, ஒருபோதும் நிறுத்தாமல் அல்லது எதையும் பிடித்து வைக்க எந்த கருவிகளையும் பயன்படுத்தாமல், துல்லியமான மற்றும் சரியான நேரத்தில் அசைவுகளை மட்டுமே பயன்படுத்தி உருவாக்க முயற்சிப்பதாக கற்பனை செய்து பாருங்கள். அதுதான் லாக்-ஃப்ரீ நுட்பங்களுக்குத் தேவையான துல்லியம் மற்றும் ஒருங்கிணைப்பின் நிலை.

ஜாவாஸ்கிரிப்டில் ஒரு கன்கரென்ட் பி-ட்ரீயை செயல்படுத்துதல்

ஜாவாஸ்கிரிப்டில் ஒரு கன்கரென்ட் பி-ட்ரீயை செயல்படுத்துவதற்கு கன்கரென்சி கட்டுப்பாட்டு வழிமுறைகள் மற்றும் ஜாவாஸ்கிரிப்ட் சூழலின் குறிப்பிட்ட பண்புகளை கவனமாக பரிசீலிக்க வேண்டும். ஜாவாஸ்கிரிப்ட் முதன்மையாக சிங்கிள்-த்ரெட்டட் என்பதால், உண்மையான இணைச்செயல்பாடு (parallelism) நேரடியாக அடைய முடியாது. இருப்பினும், கன்கரென்சியை ஒத்திசைவற்ற செயல்பாடுகள் மற்றும் வெப் வொர்க்கர்ஸ் போன்ற நுட்பங்களைப் பயன்படுத்தி உருவகப்படுத்தலாம்.

1. ஒத்திசைவற்ற செயல்பாடுகள் (Asynchronous Operations)

ஒத்திசைவற்ற செயல்பாடுகள் ஜாவாஸ்கிரிப்ட்டை நான்-பிளாக்கிங் I/O மற்றும் பிற நேரத்தைச் செலவழிக்கும் பணிகளை பிரதான த்ரெட்டை முடக்காமல் செய்ய அனுமதிக்கின்றன. Promises மற்றும் async/await ஐப் பயன்படுத்தி, செயல்பாடுகளை ஒன்றுடன் ஒன்று பின்னுவதன் மூலம் கன்கரென்சியை உருவகப்படுத்தலாம். இது I/O-பவுண்ட் பணிகள் பொதுவான Node.js சூழல்களில் குறிப்பாக பயனுள்ளதாக இருக்கும். ஒரு வலை சேவையகம் ஒரு தரவுத்தளத்திலிருந்து தரவை மீட்டெடுத்து பி-ட்ரீ அட்டவணையைப் புதுப்பிக்க வேண்டிய சூழ்நிலையைக் கவனியுங்கள். இந்தச் செயல்பாடுகளை ஒத்திசைவற்ற முறையில் செய்வதன் மூலம், சேவையகம் தரவுத்தள செயல்பாடு முடிவடையும் வரை காத்திருக்கும்போது மற்ற கோரிக்கைகளைக் கையாளத் தொடரலாம்.

2. வெப் வொர்க்கர்ஸ் (Web Workers)

வெப் வொர்க்கர்ஸ் ஜாவாஸ்கிரிப்ட் குறியீட்டை தனித்தனி த்ரெட்களில் இயக்க ஒரு வழியை வழங்குகின்றன, இது வலை உலாவிகளில் உண்மையான இணைச்செயல்பாட்டை அனுமதிக்கிறது. வெப் வொர்க்கர்ஸுக்கு DOM-க்கு நேரடி அணுகல் இல்லை என்றாலும், அவை பிரதான த்ரெட்டைத் தடுக்காமல் பின்னணியில் கணக்கீட்டு ரீதியாக தீவிரமான பணிகளைச் செய்ய முடியும். வெப் வொர்க்கர்ஸைப் பயன்படுத்தி ஒரு கன்கரென்ட் பி-ட்ரீயை செயல்படுத்த, நீங்கள் பி-ட்ரீ தரவை சீரியலைஸ் செய்து பிரதான த்ரெட் மற்றும் வொர்க்கர் த்ரெட்களுக்கு இடையில் அனுப்ப வேண்டும். ஒரு பெரிய தரவுத்தொகுப்பைச் செயலாக்கி பி-ட்ரீயில் அட்டவணைப்படுத்த வேண்டிய சூழ்நிலையைக் கவனியுங்கள். அட்டவணைப்படுத்தும் பணியை ஒரு வெப் வொர்க்கருக்கு ஆஃப்லோட் செய்வதன் மூலம், பிரதான த்ரெட் பதிலளிக்கக்கூடியதாகவே உள்ளது, இது ஒரு மென்மையான பயனர் அனுபவத்தை வழங்குகிறது.

3. ஜாவாஸ்கிரிப்டில் ரீட்-ரைட் லாக்குகளை செயல்படுத்துதல்

ஜாவாஸ்கிரிப்ட் ரீட்-ரைட் லாக்குகளை இயல்பாக ஆதரிக்காததால், Promises மற்றும் ஒரு வரிசை அடிப்படையிலான அணுகுமுறையைப் பயன்படுத்தி அவற்றை உருவகப்படுத்தலாம். இது ரீட் மற்றும் ரைட் கோரிக்கைகளுக்கு தனித்தனி வரிசைகளைப் பராமரிப்பதையும், ஒரு நேரத்தில் ஒரே ஒரு ரைட் கோரிக்கை அல்லது பல ரீட் கோரிக்கைகள் மட்டுமே செயலாக்கப்படுவதையும் உறுதி செய்வதை உள்ளடக்கியது. இதோ ஒரு எளிமைப்படுத்தப்பட்ட உதாரணம்:

class ReadWriteLock {
 constructor() {
 this.readers = [];
 this.writer = null;
 this.queue = [];
 }

 async readLock() {
 return new Promise((resolve) => {
 this.queue.push({
 type: 'read',
 resolve,
 });
 this.processQueue();
 });
 }

 async writeLock() {
 return new Promise((resolve) => {
 this.queue.push({
 type: 'write',
 resolve,
 });
 this.processQueue();
 });
 }

 unlock() {
 if (this.writer) {
 this.writer = null;
 } else {
 this.readers.shift();
 }
 this.processQueue();
 }

 async processQueue() {
 if (this.writer || this.readers.length > 0) {
 return; // Already locked
 }

 if (this.queue.length > 0) {
 const next = this.queue.shift();
 if (next.type === 'read') {
 this.readers.push(next);
 next.resolve();
 this.processQueue(); // Allow multiple readers
 } else if (next.type === 'write') {
 this.writer = next;
 next.resolve();
 }
 }
 }
}

இந்த அடிப்படைச் செயல்படுத்தல் ஜாவாஸ்கிரிப்டில் ரீட்-ரைட் லாக்கிங்கை எவ்வாறு உருவகப்படுத்துவது என்பதைக் காட்டுகிறது. ஒரு உற்பத்திக்குத் தயாரான செயல்படுத்தலுக்கு மேலும் வலுவான பிழை கையாளுதல் மற்றும் பசியைத் தடுக்க சாத்தியமான நேர்மைக் கொள்கைகள் தேவைப்படும்.

உதாரணம்: ஒரு எளிமைப்படுத்தப்பட்ட கன்கரென்ட் பி-ட்ரீ செயல்படுத்தல்

கீழே ஜாவாஸ்கிரிப்டில் ஒரு கன்கரென்ட் பி-ட்ரீயின் எளிமைப்படுத்தப்பட்ட உதாரணம் கொடுக்கப்பட்டுள்ளது. இது ஒரு அடிப்படை விளக்கம் என்பதை நினைவில் கொள்ளவும், உற்பத்திப் பயன்பாட்டிற்கு மேலும் செம்மைப்படுத்துதல் தேவை.

class BTreeNode {
 constructor(leaf = false) {
 this.keys = [];
 this.children = [];
 this.leaf = leaf;
 }
}

class ConcurrentBTree {
 constructor(t) {
 this.root = new BTreeNode(true);
 this.t = t; // Minimum degree
 this.lock = new ReadWriteLock();
 }

 async insert(key) {
 await this.lock.writeLock();
 try {
 let r = this.root;
 if (r.keys.length === 2 * this.t - 1) {
 let s = new BTreeNode();
 this.root = s;
 s.children[0] = r;
 this.splitChild(s, 0, r);
 this.insertNonFull(s, key);
 } else {
 this.insertNonFull(r, key);
 }
 } finally {
 this.lock.unlock();
 }
 }

 async insertNonFull(x, key) {
 let i = x.keys.length - 1;

 if (x.leaf) {
 while (i >= 0 && key < x.keys[i]) {
 x.keys[i + 1] = x.keys[i];
 i--;
 }
 x.keys[i + 1] = key;
 } else {
 while (i >= 0 && key < x.keys[i]) {
 i--;
 }
 i++;
 await this.lock.readLock(); // Read lock for child
 try {
 if (x.children[i].keys.length === 2 * this.t - 1) {
 this.splitChild(x, i, x.children[i]);
 if (key > x.keys[i]) {
 i++;
 }
 }
 await this.insertNonFull(x.children[i], key);
 } finally {
 this.lock.unlock(); // Unlock after accessing child
 }
 }
 }

 async splitChild(x, i, y) {
 let z = new BTreeNode(y.leaf);
 for (let j = 0; j < this.t - 1; j++) {
 z.keys[j] = y.keys[j + this.t];
 }
 if (!y.leaf) {
 for (let j = 0; j < this.t; j++) {
 z.children[j] = y.children[j + this.t];
 }
 }
 y.keys.length = this.t - 1;
 y.children.length = this.t;

 for (let j = x.keys.length; j >= i + 1; j--) {
 x.keys[j + 1] = x.keys[j];
 }
 x.keys[i] = y.keys[this.t - 1];

 for (let j = x.children.length; j >= i + 2; j--) {
 x.children[j + 1] = x.children[j];
 }
 x.children[i + 1] = z;

 x.keys.length++;
 }

 async search(key) {
 await this.lock.readLock();
 try {
 return this.searchKey(this.root, key);
 } finally {
 this.lock.unlock();
 }
 }

 async searchKey(x, key) {
 let i = 0;
 while (i < x.keys.length && key > x.keys[i]) {
 i++;
 }
 if (i < x.keys.length && key === x.keys[i]) {
 return true;
 }
 if (x.leaf) {
 return false;
 }
 await this.lock.readLock(); // Read lock for child
 try {
 return this.searchKey(x.children[i], key);
 } finally {
 this.lock.unlock(); // Unlock after accessing child
 }
 }
}

இந்த உதாரணம், கன்கரென்ட் செயல்பாடுகளின் போது பி-ட்ரீயைப் பாதுகாக்க உருவகப்படுத்தப்பட்ட ரீட்-ரைட் லாக்கைப் பயன்படுத்துகிறது. insert மற்றும் search முறைகள் ட்ரீயின் நோடுகளை அணுகுவதற்கு முன் பொருத்தமான லாக்குகளைப் பெறுகின்றன.

செயல்திறன் பரிசீலனைகள்

தரவு ஒருமைப்பாட்டிற்கு கன்கரென்சி கட்டுப்பாடு அவசியமானாலும், அது செயல்திறன் மேல்சுமையையும் அறிமுகப்படுத்தலாம். குறிப்பாக லாக்கிங் வழிமுறைகள், கவனமாக செயல்படுத்தப்படாவிட்டால், போட்டி மற்றும் குறைக்கப்பட்ட செயல்திறனுக்கு வழிவகுக்கும். எனவே, ஒரு கன்கரென்ட் பி-ட்ரீயை வடிவமைக்கும்போது பின்வரும் காரணிகளைக் கருத்தில் கொள்வது முக்கியம்:

• லாக் நுணுக்கம் (Lock Granularity): ஃபைன்-கிரைன்டு லாக்கிங் பொதுவாக கோர்ஸ்-கிரைன்டு லாக்கிங்கை விட சிறந்த கன்கரென்சியை வழங்குகிறது, ஆனால் இது லாக் நிர்வாகத்தின் சிக்கலையும் அதிகரிக்கிறது.
• லாக்கிங் உத்தி (Locking Strategy): ரைட் செயல்பாடுகளை விட ரீட் செயல்பாடுகள் அடிக்கடி நிகழும்போது ரீட்-ரைட் லாக்குகள் செயல்திறனை மேம்படுத்தலாம்.
• ஒத்திசைவற்ற செயல்பாடுகள் (Asynchronous Operations): ஒத்திசைவற்ற செயல்பாடுகளைப் பயன்படுத்துவது பிரதான த்ரெட்டைத் தடுப்பதைத் தவிர்க்க உதவும், ஒட்டுமொத்த பதிலளிப்புத்தன்மையை மேம்படுத்துகிறது.
• வெப் வொர்க்கர்ஸ் (Web Workers): கணக்கீட்டு ரீதியாக தீவிரமான பணிகளை வெப் வொர்க்கர்ஸுக்கு ஆஃப்லோட் செய்வது வலை உலாவிகளில் உண்மையான இணைச்செயல்பாட்டை வழங்க முடியும்.
• கேச் தேர்வுமுறை (Cache Optimization): லாக் பெறுவதற்கான தேவையைக் குறைக்கவும் செயல்திறனை மேம்படுத்தவும் அடிக்கடி அணுகப்படும் நோடுகளை கேச் செய்யவும்.

வெவ்வேறு கன்கரென்சி கட்டுப்பாட்டு நுட்பங்களின் செயல்திறனை மதிப்பிடுவதற்கும் சாத்தியமான இடையூறுகளைக் கண்டறிவதற்கும் பெஞ்ச்மார்க்கிங் அவசியம். Node.js-இன் உள்ளமைக்கப்பட்ட perf_hooks மாட்யூல் போன்ற கருவிகளை பல்வேறு செயல்பாடுகளின் செயல்படுத்தல் நேரத்தை அளவிடப் பயன்படுத்தலாம்.

பயன்பாட்டு வழக்குகள் மற்றும் பயன்பாடுகள்

கன்கரென்ட் பி-ட்ரீகள் பல்வேறு களங்களில் பரந்த அளவிலான பயன்பாடுகளைக் கொண்டுள்ளன, அவற்றுள்:

• தரவுத்தளங்கள் (Databases): தரவு மீட்டெடுப்பை விரைவுபடுத்த தரவுத்தளங்களில் அட்டவணைப்படுத்தலுக்கு பி-ட்ரீகள் பொதுவாகப் பயன்படுத்தப்படுகின்றன. கன்கரென்ட் பி-ட்ரீகள் பல-பயனர் தரவுத்தள அமைப்புகளில் தரவு ஒருமைப்பாடு மற்றும் செயல்திறனை உறுதி செய்கின்றன. பல சேவையகங்கள் ஒரே அட்டவணையை அணுகி மாற்ற வேண்டிய ஒரு விநியோகிக்கப்பட்ட தரவுத்தள அமைப்பைக் கவனியுங்கள். ஒரு கன்கரென்ட் பி-ட்ரீ அனைத்து சேவையகங்களிலும் அட்டவணை சீராக இருப்பதை உறுதி செய்கிறது.
• கோப்பு முறைமைகள் (File Systems): கோப்புப் பெயர்கள், அளவுகள் மற்றும் இருப்பிடங்கள் போன்ற கோப்பு முறைமை மெட்டாடேட்டாவை ஒழுங்கமைக்க பி-ட்ரீகளைப் பயன்படுத்தலாம். கன்கரென்ட் பி-ட்ரீகள் பல செயல்முறைகளை ஒரே நேரத்தில் தரவு சிதைவு இல்லாமல் கோப்பு முறைமையை அணுகவும் மாற்றவும் உதவுகின்றன.
• தேடுபொறிகள் (Search Engines): விரைவான தேடல் முடிவுகளுக்கு வலைப்பக்கங்களை அட்டவணைப்படுத்த பி-ட்ரீகளைப் பயன்படுத்தலாம். கன்கரென்ட் பி-ட்ரீகள் பல பயனர்களை செயல்திறனைப் பாதிக்காமல் ஒரே நேரத்தில் தேடல்களைச் செய்ய அனுமதிக்கின்றன. வினாடிக்கு மில்லியன் கணக்கான வினவல்களைக் கையாளும் ஒரு பெரிய தேடுபொறியை கற்பனை செய்து பாருங்கள். ஒரு கன்கரென்ட் பி-ட்ரீ அட்டவணை தேடல் முடிவுகள் விரைவாகவும் துல்லியமாகவும் வழங்கப்படுவதை உறுதி செய்கிறது.
• நிகழ்நேர அமைப்புகள் (Real-Time Systems): நிகழ்நேர அமைப்புகளில், தரவை விரைவாகவும் நம்பகத்தன்மையுடனும் அணுகவும் புதுப்பிக்கவும் வேண்டும். கன்கரென்ட் பி-ட்ரீகள் நிகழ்நேரத் தரவை நிர்வகிப்பதற்கு ஒரு வலுவான மற்றும் திறமையான தரவு கட்டமைப்பை வழங்குகின்றன. உதாரணமாக, ஒரு பங்கு வர்த்தக அமைப்பில், பங்கு விலைகளை நிகழ்நேரத்தில் சேமிக்கவும் மீட்டெடுக்கவும் ஒரு கன்கரென்ட் பி-ட்ரீயைப் பயன்படுத்தலாம்.

முடிவுரை

ஜாவாஸ்கிரிப்டில் ஒரு கன்கரென்ட் பி-ட்ரீயை செயல்படுத்துவது சவால்களையும் வாய்ப்புகளையும் அளிக்கிறது. கன்கரென்சி கட்டுப்பாட்டு வழிமுறைகள், செயல்திறன் தாக்கங்கள் மற்றும் ஜாவாஸ்கிரிப்ட் சூழலின் குறிப்பிட்ட பண்புகளை கவனமாக பரிசீலிப்பதன் மூலம், நவீன, மல்டி-த்ரெட்டட் பயன்பாடுகளின் கோரிக்கைகளை பூர்த்தி செய்யும் ஒரு வலுவான மற்றும் திறமையான தரவு கட்டமைப்பை நீங்கள் உருவாக்கலாம். ஜாவாஸ்கிரிப்டின் சிங்கிள்-த்ரெட்டட் தன்மை கன்கரென்சியை உருவகப்படுத்த ஒத்திசைவற்ற செயல்பாடுகள் மற்றும் வெப் வொர்க்கர்ஸ் போன்ற ஆக்கப்பூர்வமான அணுகுமுறைகள் தேவைப்பட்டாலும், தரவு ஒருமைப்பாடு மற்றும் செயல்திறன் ஆகியவற்றின் அடிப்படையில் நன்கு செயல்படுத்தப்பட்ட கன்கரென்ட் பி-ட்ரீயின் நன்மைகள் மறுக்க முடியாதவை. ஜாவாஸ்கிரிப்ட் தொடர்ந்து வளர்ச்சியடைந்து, சர்வர்-சைட் மற்றும் பிற செயல்திறன்-முக்கியமான களங்களில் அதன் வரம்பை விரிவுபடுத்துவதால், பி-ட்ரீ போன்ற கன்கரென்ட் தரவு கட்டமைப்புகளைப் புரிந்துகொண்டு செயல்படுத்துவதன் முக்கியத்துவம் தொடர்ந்து வளரும்.

இந்தக் கட்டுரையில் விவாதிக்கப்பட்ட கருத்துக்கள் பல்வேறு நிரலாக்க மொழிகள் மற்றும் அமைப்புகளில் பொருந்தும். நீங்கள் ஒரு உயர் செயல்திறன் கொண்ட தரவுத்தள அமைப்பு, ஒரு நிகழ்நேர பயன்பாடு அல்லது ஒரு விநியோகிக்கப்பட்ட தேடுபொறியை உருவாக்குகிறீர்களானாலும், கன்கரென்ட் பி-ட்ரீகளின் கொள்கைகளைப் புரிந்துகொள்வது உங்கள் பயன்பாடுகளின் நம்பகத்தன்மை மற்றும் அளவிடுதலை உறுதி செய்வதில் விலைமதிப்பற்றதாக இருக்கும்.